package list;

import com.sun.xml.internal.ws.streaming.MtomStreamWriter;
import org.junit.Test;

import java.applet.Applet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Collection_lterator {
    /**
     * 数组：遍历数据   遍历数据的三种：普通for  增强for  Arrays工具类
     * 集合：遍历数据   遍历数据三种： 普通for  增强for  Iterator迭代器
     * 保存数据优选：集合----变量数据优选Iterator迭代器
     * Iterator迭代器 接口---依赖Collection提供方法：iterator（）
     * 集合：迭代器使用方式：问，取，【不是必须操作】删
     */
    @Test
    public void testIterator() {
        Collection c = new ArrayList();
        c.add("one");
        c.add("tow");
        c.add("three");
        /**
         * iterator()方法：获取集合迭代器---遍历数据
         */
        Iterator<String> it = c.iterator();
        //迭代器使用：1.问--集合中是否存在元素【集合元素不确定】
        /**
         * hasNext()  返回值：boolean
         * 作用：判断集合当中是否还有元素可以遍历，返回true有元素  返回false无元素
         */
        while (it.hasNext()) {//迭代器：问操作--hasNext（）
            //取操作--如果集合中存在元素：取出元素：取出元素---next（）
            /**
             * E  next（）       返回值：E泛型  简单理解：Object
             * 作用：遍历出元素
             */
            String str = it.next();
            System.out.println("集合迭代器" + str);

        }
        /**
         * 集合三种遍历方式：Iterator迭代器【问，取操作】
         *               普通for【难度需要查API】
         *               增强for【没有难度】
         *               开发：选一种
         *               遍历同时对集合做元素删除操作---Iterator迭代器
         */
    }

    @Test
    public void testFor() {
        Collection cet = new ArrayList();
        //需求：10个元素，普通for增加元素：0到9个元素
        for (int i = 0; i < 10; i++) ;
        {
            /*cet.add(i);*/


        }
        System.out.println("打印集合数据" + cet);
        //获取集合中所有的数据---操作
        //1.使用普通for遍历 collection集合  提醒：查API
        //获取集合元素：List---方法get()
        for (int i = 0; i < cet.size(); i++) {//拿下表
            //collection.getClass();
            //System.out.Println("普通for输出集合："+i)；
            System.out.println("普通for输出集合：" + ((List) cet).get(i));
        }


    }

    //2.使用增强for遍历： 语法：for（Integer i:集合名）{}0
    //                      for（Object i:集合名）
    //collection是顶级集合--存任何数据--Object类型
    Collection a = new ArrayList();
    /*for(int i = 0;
    i<10;i++){
        a.add(i);
    }
    for(Object i = a){
        System.out.println("使用增强for输出集合：" + i);
    }*/
    /**
     * 遍历同时对集合做元素删除操作--Iterator迭代器
     * Iterator迭代器---删除操作【真删元素】
     * remove()   返回值：void
     * 作用：删除迭代器获取的元素【理解：next()取元素之后，删除】
     * 集合：迭代器使用方式：问，取，【不是必须操作删】
     */
     @Test
    public void testRemove(){
         Collection c=new ArrayList();
         c.add("嘻嘻");c.add("哈哈");
         c.add("呵呵");
         //创建集合Collection--遍历同时删除春节的元素
         System.out.println("Collection集合"+c);
         //1.依赖集合Collection--提供iterator()方法  创建迭代器对象
         Iterator it=c.iterator();
         //2.使用迭代器：问  取  删
         while(it.hasNext()){//问：集合中是否有元素
             //3.获取结合中元素 next（） 获取元素，默认类型Object
             String str=(String)it.next();
             //4.删除集合中的元素”喜喜“
             if ("嘻嘻".equals(str)){
                 it.remove();//拿到元素之后删除操作
             }
             //c.remove("");  //集合中删除  Collection中的方法


         }
         System.out.println("迭代器实现删除元素操作："+c);
     }
     @Test
    public  void   work() {
         /**
          * 集合：Iterator  通过迭代--遍历集合----遍历同时删除元素  【推荐】
          *      普通for【不推荐】
          *      增强for【不可以遍历同时删除元素】
          *      ConcurrentModificationException   并发修改异常
          *      产生原因：增强for壁层遍历采用iterator遍历---迭代器元素删除元素
          */
         Collection<String> y = new ArrayList<>();
         y.add("喜喜");
         y.add("哈哈");
         y.add("呵呵");
         System.out.println(y);

         for (String s : y) {
             if ("呵呵".equals(s)) {
                 y.remove("呵呵");
             }
             System.out.println(s);
         }
         System.out.println(y);

     }
    /**
     * 泛型：与集合搭配使用  E  element  元素  理解：Object
     * JDK1.5之后退出的新特性，集合存在热河数据，获取数据非常混乱
     *                      对象：整型 ，小数型 取  Object  知道类型
     *泛型主要功能是约束集合的类型
     * 泛型编译器认可的，JVM虚拟机不认可，认为：Object对象
     * 使用泛型的好处：1.约束类型，数据稳定【同一类型】，获取元素无需造型
     * 2.类型：对象---继承以继承之后方法使用super
     *
     *
     * 语法：Collection<类型：引用类型，包装类型> c=
     * new ArrayList<类型：引用类型，包装类型>();
     */
    @Test
    public void testElement(){
        //1.5  泛型写法
        Collection<String> a=new  ArrayList<String>();
        //1.7 泛型写法   建议使用
        Collection<String> y=new ArrayList<>();
        y.add("喜喜");y.add("呵呵");
        Iterator<String> it=y.iterator();
        while (it.hasNext()){//问数据   若存在  true
            String str=it.next();
        }
        System.out.println(y);
        Collection<Float> a1=new ArrayList<>();
        a1.add(7.7f);
        Collection<Boolean> A2=new ArrayList<>();
        A2.add(true);

        //泛型定义：？代表：不限制类型【没有意思--null】  项目非常大---功能
        Collection<?> a2=new  ArrayList<>();
        //a2.add("字符串");  a2.add(3);  a2.add(1.1f); a2.add(new Object());
        a2.add(null); //只能存没有意思的值：引用类型--默认值：null

    }
    /**
     * 泛型中通配符  ？ 【任意类型的使用】
     * ？ 【任意类型】 extend  父类
     * 【任意类型：父类的所有子类】   --约束--
     */
@Test
    public  void   test(){
    //测试创建集合----传入参数  ：引用类型  apple对象

    Collection<String> ap=new ArrayList<>();
    ap.add(new String());//存入对象












}



































































































































}
